// API配置文件
const API_CONFIG = {
    // API基础配置
    baseUrl: 'http://localhost:48080',
    endpoint: '/admin-api/graph/stream/search',
    
    // 认证信息
    auth: {
        token: '9909a1cba1b34a4caad676f9b0f7860e',
        tenantId: '1'
    },
    
    // 请求参数
    params: {
        agentId: '1',
        threadId: '11'
    }
};

// 动态生成请求头，避免重复配置
API_CONFIG.headers = {
    'authorization': `Bearer ${API_CONFIG.auth.token}`,
    'tenant-id': API_CONFIG.auth.tenantId,
    'Accept': '*/*',
    'User-Agent': 'AI-Chat-Client/1.0.0',
    'Connection': 'keep-alive'
};

// 构建完整的API URL
function buildApiUrl(query) {
    const encodedQuery = encodeURIComponent(query);
    return `${API_CONFIG.baseUrl}${API_CONFIG.endpoint}?query=${encodedQuery}&agentId=${API_CONFIG.params.agentId}&threadId=${API_CONFIG.params.threadId}`;
}

// 配置验证函数
function validateConfig() {
    const errors = [];
    
    if (!API_CONFIG.baseUrl) {
        errors.push('baseUrl 不能为空');
    }
    
    if (!API_CONFIG.auth.token) {
        errors.push('auth.token 不能为空');
    }
    
    if (!API_CONFIG.auth.tenantId) {
        errors.push('auth.tenantId 不能为空');
    }
    
    if (!API_CONFIG.params.agentId) {
        errors.push('params.agentId 不能为空');
    }
    
    if (!API_CONFIG.params.threadId) {
        errors.push('params.threadId 不能为空');
    }
    
    if (errors.length > 0) {
        console.error('配置验证失败:', errors);
        return false;
    }
    
    console.log('配置验证通过');
    return true;
}

// 更新配置函数
function updateConfig(newConfig) {
    if (newConfig.baseUrl) API_CONFIG.baseUrl = newConfig.baseUrl;
    if (newConfig.endpoint) API_CONFIG.endpoint = newConfig.endpoint;
    if (newConfig.auth) {
        if (newConfig.auth.token) API_CONFIG.auth.token = newConfig.auth.token;
        if (newConfig.auth.tenantId) API_CONFIG.auth.tenantId = newConfig.auth.tenantId;
    }
    if (newConfig.params) {
        if (newConfig.params.agentId) API_CONFIG.params.agentId = newConfig.params.agentId;
        if (newConfig.params.threadId) API_CONFIG.params.threadId = newConfig.params.threadId;
    }
    
    // 重新生成请求头
    API_CONFIG.headers = {
        'authorization': `Bearer ${API_CONFIG.auth.token}`,
        'tenant-id': API_CONFIG.auth.tenantId,
        'Accept': '*/*',
        'User-Agent': 'AI-Chat-Client/1.0.0',
        'Connection': 'keep-alive'
    };
    
    // 保存到本地存储
    saveConfigToStorage();
    
    console.log('配置已更新:', API_CONFIG);
}

// 获取当前配置
function getConfig() {
    return { ...API_CONFIG };
}

// 保存配置到本地存储
function saveConfigToStorage() {
    if (typeof window !== 'undefined' && window.localStorage) {
        try {
            const configToSave = {
                baseUrl: API_CONFIG.baseUrl,
                endpoint: API_CONFIG.endpoint,
                auth: {
                    token: API_CONFIG.auth.token,
                    tenantId: API_CONFIG.auth.tenantId
                },
                params: {
                    agentId: API_CONFIG.params.agentId,
                    threadId: API_CONFIG.params.threadId
                }
            };
            localStorage.setItem('ai-chat-config', JSON.stringify(configToSave));
            console.log('配置已保存到本地存储');
        } catch (error) {
            console.error('保存配置到本地存储失败:', error);
        }
    }
}

// 从本地存储加载配置
function loadConfigFromStorage() {
    if (typeof window !== 'undefined' && window.localStorage) {
        try {
            const savedConfig = localStorage.getItem('ai-chat-config');
            if (savedConfig) {
                const config = JSON.parse(savedConfig);
                
                // 更新API_CONFIG
                if (config.baseUrl) API_CONFIG.baseUrl = config.baseUrl;
                if (config.endpoint) API_CONFIG.endpoint = config.endpoint;
                if (config.auth) {
                    if (config.auth.token) API_CONFIG.auth.token = config.auth.token;
                    if (config.auth.tenantId) API_CONFIG.auth.tenantId = config.auth.tenantId;
                }
                if (config.params) {
                    if (config.params.agentId) API_CONFIG.params.agentId = config.params.agentId;
                    if (config.params.threadId) API_CONFIG.params.threadId = config.params.threadId;
                }
                
                // 重新生成请求头
                API_CONFIG.headers = {
                    'authorization': `Bearer ${API_CONFIG.auth.token}`,
                    'tenant-id': API_CONFIG.auth.tenantId,
                    'Accept': '*/*',
                    'User-Agent': 'AI-Chat-Client/1.0.0',
                    'Connection': 'keep-alive'
                };
                
                console.log('配置已从本地存储加载:', API_CONFIG);
                return true;
            }
        } catch (error) {
            console.error('从本地存储加载配置失败:', error);
        }
    }
    return false;
}

// 清除本地存储的配置
function clearConfigFromStorage() {
    if (typeof window !== 'undefined' && window.localStorage) {
        try {
            localStorage.removeItem('ai-chat-config');
            console.log('本地存储的配置已清除');
        } catch (error) {
            console.error('清除本地存储配置失败:', error);
        }
    }
}

// 页面加载时验证配置
if (typeof window !== 'undefined') {
    document.addEventListener('DOMContentLoaded', function() {
        // 首先尝试从本地存储加载配置
        const loaded = loadConfigFromStorage();
        if (loaded) {
            console.log('已从本地存储加载配置');
        } else {
            console.log('使用默认配置');
        }
        
        // 验证配置
        validateConfig();
    });
}

// 导出配置
if (typeof module !== 'undefined' && module.exports) {
    module.exports = { 
        API_CONFIG, 
        buildApiUrl, 
        validateConfig, 
        updateConfig, 
        getConfig,
        saveConfigToStorage,
        loadConfigFromStorage,
        clearConfigFromStorage
    };
}
